package com.wutongyu.mannyburger;

import android.content.Context;
import android.content.SharedPreferences;
import android.util.Log;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 购物车管理器，负责购物车数据的增删改查和持久化
 */
public class CartManager {
    private static final String TAG = "CartManager";
    private static final String PREF_CART = "cart_pref";
    private static final String KEY_CART_ITEMS = "cart_items";

    private static CartManager instance;
    private final List<CartItem> cartItems;
    private final Set<CartChangeListener> listeners;
    private double totalPrice = 0.0;

    /**
     * 购物车变化监听接口
     */
    public interface CartChangeListener {
        void onCartChanged(List<CartItem> cartItems, double totalPrice);
    }

    /**
     * 购物车清空监听接口
     */
    public interface CartClearListener extends CartChangeListener {
        void onCartCleared();
    }

    private CartManager() {
        cartItems = new ArrayList<>();
        listeners = new HashSet<>();
    }

    /**
     * 获取CartManager单例
     */
    public static synchronized CartManager getInstance() {
        if (instance == null) {
            instance = new CartManager();
        }
        return instance;
    }

    /**
     * 添加购物车变化监听器
     */
    public void addCartChangeListener(CartChangeListener listener) {
        if (listener != null) {
            listeners.add(listener);
        }
    }

    /**
     * 添加购物车清空监听器
     */
    public void addCartClearListener(CartClearListener listener) {
        if (listener != null) {
            listeners.add(listener);
        }
    }

    /**
     * 移除购物车变化监听器
     */
    public void removeCartChangeListener(CartChangeListener listener) {
        if (listener != null) {
            listeners.remove(listener);
        }
    }

    /**
     * 移除购物车清空监听器
     */
    public void removeCartClearListener(CartClearListener listener) {
        if (listener != null) {
            listeners.remove(listener);
        }
    }

    /**
     * 通知所有监听器购物车已变化
     */
    private void notifyCartChanged() {
        calculateTotalPrice();
        for (CartChangeListener listener : listeners) {
            listener.onCartChanged(cartItems, totalPrice);
        }
    }

    /**
     * 通知所有监听器购物车已被清空
     * 这是一个特殊的通知，可以触发更彻底的UI刷新
     */
    private void notifyCartCleared() {
        calculateTotalPrice();
        for (CartChangeListener listener : listeners) {
            if (listener instanceof CartClearListener) {
                ((CartClearListener) listener).onCartCleared();
            }
            listener.onCartChanged(cartItems, totalPrice);
        }
    }

    /**
     * 计算购物车总价
     */
    private void calculateTotalPrice() {
        totalPrice = 0.0;
        for (CartItem item : cartItems) {
            totalPrice += item.getTotalPrice();
        }
    }

    /**
     * 获取购物车中商品总数
     */
    public int getTotalItemCount() {
        int count = 0;
        for (CartItem item : cartItems) {
            count += item.getQuantity();
        }
        return count;
    }

    /**
     * 获取购物车总价
     */
    public double getTotalPrice() {
        calculateTotalPrice();
        return totalPrice;
    }

    /**
     * 获取购物车所有商品
     */
    public List<CartItem> getCartItems() {
        return new ArrayList<>(cartItems);
    }

    /**
     * 查找购物车中是否已存在该商品
     */
    private CartItem findCartItemByProduct(Product product) {
        for (CartItem item : cartItems) {
            if (item.getProduct() != null && 
                item.getProduct().getId() == product.getId()) {
                return item;
            }
        }
        return null;
    }

    /**
     * 增加商品到购物车
     */
    public void addProduct(Product product) {
        if (product == null) return;

        CartItem existingItem = findCartItemByProduct(product);
        if (existingItem != null) {
            existingItem.increaseQuantity();
        } else {
            CartItem newItem = new CartItem(product, 1);
            cartItems.add(newItem);
        }

        notifyCartChanged();
    }

    /**
     * 从购物车移除商品
     */
    public void removeProduct(Product product) {
        if (product == null) return;

        CartItem existingItem = findCartItemByProduct(product);
        if (existingItem != null) {
            existingItem.decreaseQuantity();
            if (existingItem.getQuantity() <= 0) {
                cartItems.remove(existingItem);
            }
        }

        notifyCartChanged();
    }

    /**
     * 设置商品数量
     */
    public void setProductQuantity(Product product, int quantity) {
        if (product == null) return;

        if (quantity <= 0) {
            removeCartItem(product);
            return;
        }

        CartItem existingItem = findCartItemByProduct(product);
        if (existingItem != null) {
            existingItem.setQuantity(quantity);
        } else {
            CartItem newItem = new CartItem(product, quantity);
            cartItems.add(newItem);
        }

        notifyCartChanged();
    }

    /**
     * 从购物车完全移除商品
     */
    public void removeCartItem(Product product) {
        if (product == null) return;

        CartItem existingItem = findCartItemByProduct(product);
        if (existingItem != null) {
            cartItems.remove(existingItem);
            notifyCartChanged();
        }
    }

    /**
     * 从购物车中移除商品
     * 与removeCartItem方法功能相同，提供API兼容性
     */
    public void removeFromCart(Product product) {
        removeCartItem(product);
    }

    /**
     * 添加商品到购物车
     * 与addProduct方法功能相同，提供API兼容性
     */
    public void addToCart(Product product) {
        addProduct(product);
    }

    /**
     * 更新购物车中商品的数量
     * 使用Product对象当前的数量更新购物车
     */
    public void updateCartItemQuantity(Product product) {
        if (product == null) return;
        setProductQuantity(product, product.getQuantity());
    }

    /**
     * 清空购物车
     */
    public void clearCart() {
        cartItems.clear();
        notifyCartCleared();
    }

    /**
     * 购物车是否为空
     */
    public boolean isEmpty() {
        return cartItems.isEmpty();
    }

    /**
     * 保存购物车数据到SharedPreferences
     */
    public void saveCart(Context context) {
        if (context == null) return;

        try {
            SharedPreferences prefs = context.getSharedPreferences(PREF_CART, Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = prefs.edit();
            
            Gson gson = new Gson();
            String cartJson = gson.toJson(cartItems);
            
            editor.putString(KEY_CART_ITEMS, cartJson);
            editor.apply();
            
            Log.d(TAG, "购物车已保存: " + cartItems.size() + "项");
        } catch (Exception e) {
            Log.e(TAG, "保存购物车失败: " + e.getMessage());
        }
    }

    /**
     * 从SharedPreferences加载购物车数据
     */
    public void loadCart(Context context) {
        if (context == null) return;

        try {
            SharedPreferences prefs = context.getSharedPreferences(PREF_CART, Context.MODE_PRIVATE);
            String cartJson = prefs.getString(KEY_CART_ITEMS, null);
            
            if (cartJson != null && !cartJson.isEmpty()) {
                Gson gson = new Gson();
                Type type = new TypeToken<ArrayList<CartItem>>(){}.getType();
                List<CartItem> loadedItems = gson.fromJson(cartJson, type);
                
                cartItems.clear();
                if (loadedItems != null) {
                    cartItems.addAll(loadedItems);
                }
                
                Log.d(TAG, "购物车已加载: " + cartItems.size() + "项");
                notifyCartChanged();
            }
        } catch (Exception e) {
            Log.e(TAG, "加载购物车失败: " + e.getMessage());
        }
    }
} 